#!/usr/bin/env python3
"""
智能文档生成 MCP Server
基于模型上下文协议的文档自动生成服务
"""

import asyncio
import json
import logging
import os
import re
import tempfile
import uuid
from datetime import datetime
from pathlib import Path
from typing import Dict, List, Optional, Tuple, Any
from dataclasses import dataclass, asdict
from enum import Enum

# 第三方库导入
import httpx
from docx import Document
from docx.shared import Inches
from docx.enum.text import WD_ALIGN_PARAGRAPH
import jieba
import jieba.analyse
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

# MCP相关导入
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from mcp.types import (
    CallToolRequest,
    CallToolResult,
    GetPromptRequest,
    GetPromptResult,
    ListPromptsRequest,
    ListPromptsResult,
    ListResourcesRequest,
    ListResourcesResult,
    ListToolsRequest,
    ListToolsResult,
    Prompt,
    Resource,
    TextContent,
    Tool,
)

# 配置日志
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class DocumentType(Enum):
    """文档类型枚举"""
    WEEKLY_REPORT = "weekly_report"
    MEETING_MINUTES = "meeting_minutes"
    REQUIREMENT_DOC = "requirement_doc"
    TECHNICAL_DESIGN = "technical_design"
    PROJECT_PROPOSAL = "project_proposal"
    RISK_ASSESSMENT = "risk_assessment"

@dataclass
class DocumentTemplate:
    """文档模板数据结构"""
    id: str
    name: str
    doc_type: DocumentType
    description: str
    fields: List[str]
    keywords: List[str]
    template_path: str
    priority: int = 0

@dataclass
class GenerationContext:
    """文档生成上下文"""
    user_id: str
    question: str
    matched_template: DocumentTemplate
    generated_content: Dict[str, str]
    file_path: str
    timestamp: datetime

class TemplateManager:
    """模板管理器"""
    
    def __init__(self, templates_dir: str = "templates"):
        self.templates_dir = Path(templates_dir)
        self.templates: Dict[str, DocumentTemplate] = {}
        self.vectorizer = TfidfVectorizer(stop_words=None)
        self._initialize_templates()
        
    def _initialize_templates(self):
        """初始化模板库"""
        templates_config = [
            {
                "id": "weekly_report",
                "name": "项目周报",
                "doc_type": DocumentType.WEEKLY_REPORT,
                "description": "项目进度周报模板，包含工作总结和计划",
                "fields": ["项目名称", "本周完成工作", "遇到问题", "下周计划", "风险提示"],
                "keywords": ["周报", "项目", "进度", "工作总结", "计划", "完成", "问题"],
                "template_path": "weekly_report_template.docx",
                "priority": 10
            },
            {
                "id": "meeting_minutes",
                "name": "会议纪要",
                "doc_type": DocumentType.MEETING_MINUTES,
                "description": "会议记录模板，包含议题讨论和决议",
                "fields": ["会议主题", "参会人员", "会议时间", "议题讨论", "决议事项", "行动项"],
                "keywords": ["会议", "纪要", "议题", "决议", "讨论", "参会", "行动"],
                "template_path": "meeting_minutes_template.docx",
                "priority": 8
            },
            {
                "id": "requirement_doc",
                "name": "产品需求文档",
                "doc_type": DocumentType.REQUIREMENT_DOC,
                "description": "产品功能需求文档模板",
                "fields": ["需求背景", "功能描述", "用户故事", "验收标准", "优先级", "依赖关系"],
                "keywords": ["需求", "功能", "产品", "用户故事", "验收", "PRD"],
                "template_path": "requirement_doc_template.docx",
                "priority": 9
            },
            {
                "id": "technical_design",
                "name": "技术方案设计",
                "doc_type": DocumentType.TECHNICAL_DESIGN,
                "description": "技术架构和实施方案设计文档",
                "fields": ["方案背景", "技术架构", "实施步骤", "风险评估", "时间安排", "资源需求"],
                "keywords": ["技术", "方案", "架构", "设计", "实施", "评估"],
                "template_path": "technical_design_template.docx",
                "priority": 7
            },
            {
                "id": "project_proposal",
                "name": "项目立项书",
                "doc_type": DocumentType.PROJECT_PROPOSAL,
                "description": "项目立项申请文档模板",
                "fields": ["项目背景", "目标说明", "可行性分析", "资源预算", "时间规划", "风险分析"],
                "keywords": ["项目", "立项", "申请", "背景", "目标", "预算", "规划"],
                "template_path": "project_proposal_template.docx",
                "priority": 6
            }
        ]
        
        for config in templates_config:
            template = DocumentTemplate(**config)
            self.templates[template.id] = template
            
        # 创建模板目录
        self.templates_dir.mkdir(exist_ok=True)
        self._create_template_files()
        
    def _create_template_files(self):
        """创建Word模板文件"""
        for template in self.templates.values():
            template_path = self.templates_dir / template.template_path
            if not template_path.exists():
                self._create_word_template(template, template_path)
    
    def _create_word_template(self, template: DocumentTemplate, file_path: Path):
        """创建Word模板文件"""
        doc = Document()
        
        # 添加标题
        title = doc.add_heading(template.name, 0)
        title.alignment = WD_ALIGN_PARAGRAPH.CENTER
        
        # 添加基本信息表格
        info_table = doc.add_table(rows=3, cols=2)
        info_table.style = 'Table Grid'
        
        info_cells = [
            ("文档类型", template.name),
            ("创建时间", "{{创建时间}}"),
            ("创建人", "{{创建人}}")
        ]
        
        for i, (label, value) in enumerate(info_cells):
            info_table.cell(i, 0).text = label
            info_table.cell(i, 1).text = value
        
        doc.add_paragraph()  # 空行
        
        # 为每个字段添加章节
        for i, field in enumerate(template.fields, 1):
            heading = doc.add_heading(f"{i}. {field}", level=1)
            placeholder = doc.add_paragraph(f"{{{{{field}}}}}")
            placeholder.style = 'Normal'
            doc.add_paragraph()  # 空行
        
        # 保存模板文件
        doc.save(str(file_path))
        logger.info(f"创建模板文件: {file_path}")
    
    def match_template(self, question: str) -> Tuple[DocumentTemplate, float]:
        """智能匹配最佳模板"""
        # 使用jieba进行中文分词
        question_words = list(jieba.cut(question))
        question_text = " ".join(question_words)
        
        best_template = None
        best_score = 0.0
        
        # 计算每个模板的匹配分数
        for template in self.templates.values():
            score = self._calculate_match_score(question_text, template)
            logger.info(f"模板 {template.name} 匹配分数: {score:.3f}")
            
            if score > best_score:
                best_score = score
                best_template = template
        
        # 如果没有找到合适的模板，返回默认的项目周报模板
        if best_template is None or best_score < 0.1:
            best_template = self.templates["weekly_report"]
            best_score = 0.1
            
        logger.info(f"最佳匹配模板: {best_template.name} (分数: {best_score:.3f})")
        return best_template, best_score
    
    def _calculate_match_score(self, question: str, template: DocumentTemplate) -> float:
        """计算匹配分数"""
        # 关键词匹配分数
        keyword_score = 0.0
        question_lower = question.lower()
        
        for keyword in template.keywords:
            if keyword in question_lower:
                keyword_score += 1.0
        
        # 归一化关键词分数
        if template.keywords:
            keyword_score = keyword_score / len(template.keywords)
        
        # TF-IDF相似度分数
        try:
            template_text = " ".join(template.keywords + template.fields)
            corpus = [question, template_text]
            tfidf_vectors = self.vectorizer.fit_transform(corpus)
            similarity_matrix = cosine_similarity(tfidf_vectors)
            tfidf_score = similarity_matrix[0][1]
        except:
            tfidf_score = 0.0
        
        # 综合分数（关键词匹配权重0.7，TF-IDF权重0.3）
        final_score = 0.7 * keyword_score + 0.3 * tfidf_score
        
        # 考虑模板优先级
        priority_bonus = template.priority / 100.0
        final_score += priority_bonus
        
        return final_score

class ContentGenerator:
    """内容生成器"""
    
    def __init__(self, api_key: Optional[str] = None):
        self.api_key = api_key or os.getenv("OPENAI_API_KEY")
        
    async def generate_content(self, template: DocumentTemplate, question: str, 
                             context: Dict[str, Any] = None) -> Dict[str, str]:
        """生成文档内容"""
        content = {}
        
        # 基础信息填充
        content["创建时间"] = datetime.now().strftime("%Y年%m月%d日")
        content["创建人"] = context.get("user_id", "系统用户") if context else "系统用户"
        
        # 为每个字段生成内容
        for field in template.fields:
            generated_text = await self._generate_field_content(
                field, question, template, context
            )
            content[field] = generated_text
            
        logger.info(f"为模板 {template.name} 生成了 {len(content)} 个字段的内容")
        return content
    
    async def _generate_field_content(self, field: str, question: str, 
                                    template: DocumentTemplate, context: Dict[str, Any]) -> str:
        """为特定字段生成内容"""
        # 这里模拟内容生成，实际环境中应调用大模型API
        
        content_templates = {
            "项目名称": self._extract_project_name(question),
            "本周完成工作": self._generate_work_summary(question),
            "遇到问题": self._generate_issues(question),
            "下周计划": self._generate_next_plans(question),
            "风险提示": self._generate_risks(question),
            "会议主题": self._extract_meeting_topic(question),
            "参会人员": "待补充参会人员信息",
            "会议时间": datetime.now().strftime("%Y年%m月%d日"),
            "议题讨论": self._generate_discussion_points(question),
            "决议事项": self._generate_decisions(question),
            "行动项": self._generate_action_items(question),
            "需求背景": self._generate_requirement_background(question),
            "功能描述": self._generate_feature_description(question),
            "用户故事": self._generate_user_stories(question),
            "验收标准": self._generate_acceptance_criteria(question),
            "优先级": "高",
            "依赖关系": "待分析依赖关系",
            "方案背景": self._generate_solution_background(question),
            "技术架构": self._generate_architecture(question),
            "实施步骤": self._generate_implementation_steps(question),
            "风险评估": self._generate_risk_assessment(question),
            "时间安排": self._generate_timeline(question),
            "资源需求": self._generate_resource_requirements(question)
        }
        
        return content_templates.get(field, f"请补充{field}相关内容")
    
    def _extract_project_name(self, question: str) -> str:
        """提取项目名称"""
        # 简单的项目名称提取逻辑
        if "项目" in question:
            # 尝试提取项目名称
            import re
            pattern = r'([^\s]*项目[^\s]*)'
            matches = re.findall(pattern, question)
            if matches:
                return matches[0]
        return "项目名称待定"
    
    def _generate_work_summary(self, question: str) -> str:
        """生成工作总结"""
        return """本周主要完成以下工作：
1. 完成了核心功能开发，包括用户界面优化和后端逻辑实现
2. 进行了系统测试，修复了发现的关键问题
3. 完成了文档编写和代码review工作
4. 与相关团队进行了需求确认和技术对接"""
    
    def _generate_issues(self, question: str) -> str:
        """生成问题描述"""
        return """本周遇到的主要问题：
1. 第三方接口响应时间较长，影响用户体验
2. 部分边界条件处理还需要进一步优化
3. 测试环境配置存在一些兼容性问题

已采取的解决措施：
- 正在与第三方供应商协调接口优化事宜
- 计划下周完成边界条件的完善
- 已联系运维团队解决环境配置问题"""
    
    def _generate_next_plans(self, question: str) -> str:
        """生成下周计划"""
        return """下周工作计划：
1. 完成剩余功能模块的开发和测试
2. 进行性能优化和代码重构
3. 准备项目验收相关材料
4. 协调上线部署相关事宜"""
    
    def _generate_risks(self, question: str) -> str:
        """生成风险提示"""
        return """潜在风险及应对措施：
• 技术风险：新技术栈的学习曲线可能影响开发进度
• 资源风险：关键人员可能存在时间冲突
• 外部风险：第三方服务的稳定性需要持续关注

建议：提前做好备用方案，加强团队协作和沟通"""
    
    def _extract_meeting_topic(self, question: str) -> str:
        """提取会议主题"""
        if "会议" in question:
            return "根据需求确定的会议主题"
        return "会议主题待定"
    
    def _generate_discussion_points(self, question: str) -> str:
        """生成讨论要点"""
        return """主要讨论内容：
1. 项目当前进展情况汇报
2. 遇到的技术难点和解决方案讨论
3. 资源配置和时间安排优化
4. 下阶段工作重点确认"""
    
    def _generate_decisions(self, question: str) -> str:
        """生成决议事项"""
        return """会议决议：
1. 确认项目按计划推进，关键节点不变
2. 批准增加技术资源投入
3. 建立定期沟通机制
4. 确定下次会议时间和议题"""
    
    def _generate_action_items(self, question: str) -> str:
        """生成行动项"""
        return """行动项分配：
• 技术团队：完成核心功能开发（截止日期：本周五）
• 产品团队：确认最终需求规格（截止日期：下周二）
• 测试团队：制定详细测试计划（截止日期：下周三）
• 项目经理：协调资源和时间安排（持续跟进）"""
    
    def _generate_requirement_background(self, question: str) -> str:
        """生成需求背景"""
        return """需求背景：
随着业务的快速发展，现有系统已无法满足日益增长的用户需求。为了提升用户体验，优化业务流程，提高运营效率，需要开发新的功能模块来解决当前面临的关键问题。

市场调研显示，类似功能的实现将显著提升用户满意度和业务价值。"""
    
    def _generate_feature_description(self, question: str) -> str:
        """生成功能描述"""
        return """功能详细描述：
本功能旨在为用户提供便捷、高效的操作体验。主要包括：

核心功能：
- 智能化的数据处理和分析
- 直观友好的用户界面
- 实时反馈和状态更新
- 多终端适配支持

辅助功能：
- 数据导入导出
- 操作日志记录
- 权限控制管理"""
    
    def _generate_user_stories(self, question: str) -> str:
        """生成用户故事"""
        return """用户故事：

作为一个普通用户，我希望能够快速完成任务操作，以便提高工作效率。
验收条件：用户能在3步内完成主要操作流程

作为一个管理员，我希望能够监控系统使用情况，以便及时发现和解决问题。
验收条件：提供完整的使用统计和异常监控功能

作为一个移动端用户，我希望在手机上也能正常使用所有功能，以便随时随地处理工作。
验收条件：移动端功能与PC端保持一致"""
    
    def _generate_acceptance_criteria(self, question: str) -> str:
        """生成验收标准"""
        return """验收标准：

功能性要求：
✓ 所有核心功能正常运行
✓ 用户界面友好易用
✓ 数据处理准确无误
✓ 系统响应时间<2秒

非功能性要求：
✓ 系统可用性≥99.5%
✓ 并发用户数≥1000
✓ 数据安全性符合规范
✓ 兼容主流浏览器"""
    
    def _generate_solution_background(self, question: str) -> str:
        """生成方案背景"""
        return """技术方案背景：
基于当前业务需求和技术发展趋势，需要设计一套可扩展、高性能的技术解决方案。该方案将充分考虑系统的稳定性、安全性和可维护性，为业务的长期发展提供技术保障。"""
    
    def _generate_architecture(self, question: str) -> str:
        """生成技术架构"""
        return """技术架构设计：

系统架构采用微服务架构模式：
• 前端：React + TypeScript
• 后端：Python FastAPI + PostgreSQL
• 缓存：Redis
• 消息队列：RabbitMQ
• 容器化：Docker + Kubernetes
• 监控：Prometheus + Grafana

架构优势：
- 高可用性和可扩展性
- 服务解耦，便于维护
- 支持灰度发布和快速回滚"""
    
    def _generate_implementation_steps(self, question: str) -> str:
        """生成实施步骤"""
        return """实施计划：

第一阶段（第1-2周）：
1. 环境准备和基础设施搭建
2. 核心框架搭建和基础组件开发
3. 数据库设计和初始化

第二阶段（第3-4周）：
1. 核心业务逻辑开发
2. API接口开发和测试
3. 前端界面开发

第三阶段（第5-6周）：
1. 系统集成测试
2. 性能优化和安全加固
3. 部署上线和验收"""
    
    def _generate_risk_assessment(self, question: str) -> str:
        """生成风险评估"""
        return """风险评估：

高风险项：
• 技术选型风险：新技术栈可能存在未知问题
  应对措施：提前进行技术验证和原型开发

• 人员风险：关键技术人员可能变动
  应对措施：建立知识分享机制，培养备用人员

中等风险项：
• 进度风险：需求变更可能影响开发进度
  应对措施：建立变更控制流程

• 集成风险：第三方系统集成可能出现问题
  应对措施：提前进行接口测试和验证"""
    
    def _generate_timeline(self, question: str) -> str:
        """生成时间安排"""
        return """项目时间安排：

项目总周期：6周

详细时间线：
• 第1周：需求确认和技术方案设计
• 第2周：环境搭建和框架开发
• 第3-4周：核心功能开发
• 第5周：测试和优化
• 第6周：部署上线和验收

关键里程碑：
- 技术方案评审：第1周末
- 原型演示：第2周末
- 功能开发完成：第4周末
- 系统上线：第6周末"""
    
    def _generate_resource_requirements(self, question: str) -> str:
        """生成资源需求"""
        return """资源需求：

人力资源：
• 项目经理：1人，全程参与
• 架构师：1人，前2周重点参与
• 后端开发：2人，全程参与
• 前端开发：2人，第2-5周参与
• 测试工程师：1人，第4-6周参与

技术资源：
• 开发环境：云服务器 4核8G × 3台
• 测试环境：云服务器 8核16G × 2台
• 生产环境：云服务器 16核32G × 3台
• 数据库：PostgreSQL集群
• 其他：域名、SSL证书、监控工具等"""

class DocumentProcessor:
    """文档处理器"""
    
    def __init__(self, output_dir: str = "generated_docs"):
        self.output_dir = Path(output_dir)
        self.output_dir.mkdir(exist_ok=True)
    
    def generate_document(self, template: DocumentTemplate, content: Dict[str, str], 
                         user_id: str) -> str:
        """生成最终文档"""
        # 生成文件名
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"{template.name}-{user_id}-{timestamp}.docx"
        output_path = self.output_dir / filename
        
        # 加载模板文件
        template_path = Path("templates") / template.template_path
        
        if template_path.exists():
            doc = Document(str(template_path))
        else:
            # 如果模板文件不存在，创建新文档
            doc = Document()
            doc.add_heading(template.name, 0)
        
        # 替换内容中的占位符
        self._replace_placeholders(doc, content)
        
        # 保存文档
        doc.save(str(output_path))
        
        logger.info(f"生成文档: {output_path}")
        return str(output_path)
    
    def _replace_placeholders(self, doc: Document, content: Dict[str, str]):
        """替换文档中的占位符"""
        # 替换段落中的占位符
        for paragraph in doc.paragraphs:
            for key, value in content.items():
                placeholder = f"{{{{{key}}}}}"
                if placeholder in paragraph.text:
                    paragraph.text = paragraph.text.replace(placeholder, value)
        
        # 替换表格中的占位符
        for table in doc.tables:
            for row in table.rows:
                for cell in row.cells:
                    for key, value in content.items():
                        placeholder = f"{{{{{key}}}}}"
                        if placeholder in cell.text:
                            cell.text = cell.text.replace(placeholder, value)

class MCPDocumentServer:
    """MCP文档生成服务器"""
    
    def __init__(self):
        self.template_manager = TemplateManager()
        self.content_generator = ContentGenerator()
        self.document_processor = DocumentProcessor()
        self.generation_contexts: Dict[str, GenerationContext] = {}
    
    async def handle_generate_document(self, args: Dict[str, Any]) -> Dict[str, Any]:
        """处理文档生成请求"""
        try:
            # 提取参数
            question = args.get("question", "")
            user_id = args.get("user_id", f"user_{uuid.uuid4().hex[:8]}")
            context = args.get("context", {})
            
            if not question:
                return {
                    "success": False,
                    "error": "问题描述不能为空"
                }
            
            logger.info(f"开始处理文档生成请求: {question[:50]}...")
            
            # 步骤1: 模板匹配
            matched_template, match_score = self.template_manager.match_template(question)
            logger.info(f"匹配到模板: {matched_template.name} (匹配度: {match_score:.3f})")
            
            # 步骤2: 内容生成
            generated_content = await self.content_generator.generate_content(
                matched_template, question, context
            )
            
            # 步骤3: 文档生成
            file_path = self.document_processor.generate_document(
                matched_template, generated_content, user_id
            )
            
            # 保存生成上下文
            generation_context = GenerationContext(
                user_id=user_id,
                question=question,
                matched_template=matched_template,
                generated_content=generated_content,
                file_path=file_path,
                timestamp=datetime.now()
            )
            
            context_id = str(uuid.uuid4())
            self.generation_contexts[context_id] = generation_context
            
            # 构建返回结果
            result = {
                "success": True,
                "context_id": context_id,
                "template_matched": {
                    "id": matched_template.id,
                    "name": matched_template.name,
                    "description": matched_template.description,
                    "match_score": match_score
                },
                "file_info": {
                    "filename": Path(file_path).name,
                    "path": file_path,
                    "size": os.path.getsize(file_path) if os.path.exists(file_path) else 0
                },
                "generated_fields": list(generated_content.keys()),
                "timestamp": generation_context.timestamp.isoformat()
            }
            
            logger.info(f"文档生成成功: {file_path}")
            return result
            
        except Exception as e:
            logger.error(f"文档生成失败: {str(e)}")
            return {
                "success": False,
                "error": f"文档生成失败: {str(e)}"
            }
    
    async def handle_list_templates(self, args: Dict[str, Any]) -> Dict[str, Any]:
        """列出所有可用模板"""
        try:
            templates = []
            for template in self.template_manager.templates.values():
                templates.append({
                    "id": template.id,
                    "name": template.name,
                    "description": template.description,
                    "doc_type": template.doc_type.value,
                    "fields": template.fields,
                    "keywords": template.keywords,
                    "priority": template.priority
                })
            
            return {
                "success": True,
                "templates": templates,
                "total": len(templates)
            }
            
        except Exception as e:
            logger.error(f"获取模板列表失败: {str(e)}")
            return {
                "success": False,
                "error": f"获取模板列表失败: {str(e)}"
            }
    
    async def handle_get_generation_context(self, args: Dict[str, Any]) -> Dict[str, Any]:
        """获取生成上下文信息"""
        try:
            context_id = args.get("context_id", "")
            
            if not context_id or context_id not in self.generation_contexts:
                return {
                    "success": False,
                    "error": "无效的上下文ID"
                }
            
            context = self.generation_contexts[context_id]
            
            return {
                "success": True,
                "context": {
                    "user_id": context.user_id,
                    "question": context.question,
                    "template": {
                        "id": context.matched_template.id,
                        "name": context.matched_template.name,
                        "description": context.matched_template.description
                    },
                    "generated_content": context.generated_content,
                    "file_path": context.file_path,
                    "timestamp": context.timestamp.isoformat()
                }
            }
            
        except Exception as e:
            logger.error(f"获取生成上下文失败: {str(e)}")
            return {
                "success": False,
                "error": f"获取生成上下文失败: {str(e)}"
            }
    
    async def handle_analyze_question(self, args: Dict[str, Any]) -> Dict[str, Any]:
        """分析用户问题并推荐模板"""
        try:
            question = args.get("question", "")
            
            if not question:
                return {
                    "success": False,
                    "error": "问题描述不能为空"
                }
            
            # 分析问题并获取所有模板的匹配分数
            analysis_results = []
            
            for template in self.template_manager.templates.values():
                score = self.template_manager._calculate_match_score(question, template)
                analysis_results.append({
                    "template": {
                        "id": template.id,
                        "name": template.name,
                        "description": template.description,
                        "fields": template.fields
                    },
                    "match_score": score,
                    "confidence": "高" if score > 0.6 else "中" if score > 0.3 else "低"
                })
            
            # 按匹配分数排序
            analysis_results.sort(key=lambda x: x["match_score"], reverse=True)
            
            # 提取问题中的关键词
            keywords = list(jieba.analyse.extract_tags(question, topK=10))
            
            return {
                "success": True,
                "analysis": {
                    "question": question,
                    "extracted_keywords": keywords,
                    "recommended_templates": analysis_results[:3],  # 推荐前3个
                    "all_matches": analysis_results
                }
            }
            
        except Exception as e:
            logger.error(f"问题分析失败: {str(e)}")
            return {
                "success": False,
                "error": f"问题分析失败: {str(e)}"
            }
    
    async def handle_preview_template(self, args: Dict[str, Any]) -> Dict[str, Any]:
        """预览模板结构"""
        try:
            template_id = args.get("template_id", "")
            
            if not template_id or template_id not in self.template_manager.templates:
                return {
                    "success": False,
                    "error": "无效的模板ID"
                }
            
            template = self.template_manager.templates[template_id]
            
            # 生成示例内容
            sample_content = {}
            for field in template.fields:
                sample_content[field] = f"[{field}的示例内容]"
            
            return {
                "success": True,
                "template_preview": {
                    "id": template.id,
                    "name": template.name,
                    "description": template.description,
                    "doc_type": template.doc_type.value,
                    "fields": template.fields,
                    "keywords": template.keywords,
                    "sample_content": sample_content,
                    "template_structure": self._generate_template_structure(template)
                }
            }
            
        except Exception as e:
            logger.error(f"模板预览失败: {str(e)}")
            return {
                "success": False,
                "error": f"模板预览失败: {str(e)}"
            }
    
    def _generate_template_structure(self, template: DocumentTemplate) -> str:
        """生成模板结构预览"""
        structure = f"# {template.name}\n\n"
        structure += "## 基本信息\n"
        structure += "- 文档类型: {}\n".format(template.name)
        structure += "- 创建时间: {{创建时间}}\n"
        structure += "- 创建人: {{创建人}}\n\n"
        
        for i, field in enumerate(template.fields, 1):
            structure += f"## {i}. {field}\n"
            structure += f"{{{{{field}}}}}\n\n"
        
        return structure
    
    async def handle_regenerate_field(self, args: Dict[str, Any]) -> Dict[str, Any]:
        """重新生成指定字段的内容"""
        try:
            context_id = args.get("context_id", "")
            field_name = args.get("field_name", "")
            custom_prompt = args.get("custom_prompt", "")
            
            if not context_id or context_id not in self.generation_contexts:
                return {
                    "success": False,
                    "error": "无效的上下文ID"
                }
            
            if not field_name:
                return {
                    "success": False,
                    "error": "字段名称不能为空"
                }
            
            context = self.generation_contexts[context_id]
            
            # 重新生成指定字段的内容
            new_content = await self.content_generator._generate_field_content(
                field_name, 
                context.question + " " + custom_prompt,
                context.matched_template,
                {"user_id": context.user_id}
            )
            
            # 更新上下文中的内容
            context.generated_content[field_name] = new_content
            
            # 重新生成文档
            new_file_path = self.document_processor.generate_document(
                context.matched_template,
                context.generated_content,
                context.user_id
            )
            
            context.file_path = new_file_path
            context.timestamp = datetime.now()
            
            return {
                "success": True,
                "field_name": field_name,
                "new_content": new_content,
                "updated_file": {
                    "filename": Path(new_file_path).name,
                    "path": new_file_path,
                    "size": os.path.getsize(new_file_path) if os.path.exists(new_file_path) else 0
                },
                "timestamp": context.timestamp.isoformat()
            }
            
        except Exception as e:
            logger.error(f"字段重新生成失败: {str(e)}")
            return {
                "success": False,
                "error": f"字段重新生成失败: {str(e)}"
            }

class MCPServer:
    """MCP服务器主类"""
    
    def __init__(self):
        self.doc_server = MCPDocumentServer()
        self._setup_tools()
        self._setup_prompts()
        self._setup_resources()
    
    def _setup_tools(self):
        """设置可用工具"""
        self.tools = [
            Tool(
                name="generate_document",
                description="根据用户问题生成文档",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "question": {
                            "type": "string",
                            "description": "用户的问题或需求描述"
                        },
                        "user_id": {
                            "type": "string",
                            "description": "用户ID（可选）"
                        },
                        "context": {
                            "type": "object",
                            "description": "额外的上下文信息（可选）"
                        }
                    },
                    "required": ["question"]
                }
            ),
            Tool(
                name="list_templates",
                description="列出所有可用的文档模板",
                inputSchema={
                    "type": "object",
                    "properties": {}
                }
            ),
            Tool(
                name="analyze_question",
                description="分析用户问题并推荐合适的模板",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "question": {
                            "type": "string",
                            "description": "要分析的问题"
                        }
                    },
                    "required": ["question"]
                }
            ),
            Tool(
                name="preview_template",
                description="预览指定模板的结构和示例内容",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "template_id": {
                            "type": "string",
                            "description": "模板ID"
                        }
                    },
                    "required": ["template_id"]
                }
            ),
            Tool(
                name="get_generation_context",
                description="获取文档生成的上下文信息",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "context_id": {
                            "type": "string",
                            "description": "生成上下文的ID"
                        }
                    },
                    "required": ["context_id"]
                }
            ),
            Tool(
                name="regenerate_field",
                description="重新生成文档中指定字段的内容",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "context_id": {
                            "type": "string",
                            "description": "生成上下文的ID"
                        },
                        "field_name": {
                            "type": "string",
                            "description": "要重新生成的字段名称"
                        },
                        "custom_prompt": {
                            "type": "string",
                            "description": "自定义提示词（可选）"
                        }
                    },
                    "required": ["context_id", "field_name"]
                }
            )
        ]
    
    def _setup_prompts(self):
        """设置系统提示词"""
        self.prompts = [
            Prompt(
                name="document_generation_system",
                description="文档生成系统的核心提示词",
                arguments=[
                    {
                        "name": "user_question",
                        "description": "用户的问题或需求",
                        "required": True
                    },
                    {
                        "name": "template_info",
                        "description": "匹配的模板信息",
                        "required": True
                    }
                ]
            ),
            Prompt(
                name="content_optimization",
                description="优化生成内容的提示词",
                arguments=[
                    {
                        "name": "field_name",
                        "description": "要优化的字段名称",
                        "required": True
                    },
                    {
                        "name": "current_content",
                        "description": "当前内容",
                        "required": True
                    }
                ]
            )
        ]
    
    def _setup_resources(self):
        """设置系统资源"""
        self.resources = [
            Resource(
                uri="template://templates",
                name="Document Templates",
                description="可用的文档模板资源",
                mimeType="application/json"
            ),
            Resource(
                uri="config://generation_config",
                name="Generation Configuration",
                description="内容生成配置",
                mimeType="application/json"
            )
        ]
    
    async def handle_list_tools(self, request: ListToolsRequest) -> ListToolsResult:
        """处理工具列表请求"""
        return ListToolsResult(tools=self.tools)
    
    async def handle_call_tool(self, request: CallToolRequest) -> CallToolResult:
        """处理工具调用请求"""
        try:
            tool_name = request.params.name
            args = request.params.arguments or {}
            
            # 路由到对应的处理函数
            handlers = {
                "generate_document": self.doc_server.handle_generate_document,
                "list_templates": self.doc_server.handle_list_templates,
                "analyze_question": self.doc_server.handle_analyze_question,
                "preview_template": self.doc_server.handle_preview_template,
                "get_generation_context": self.doc_server.handle_get_generation_context,
                "regenerate_field": self.doc_server.handle_regenerate_field
            }
            
            if tool_name not in handlers:
                return CallToolResult(
                    content=[TextContent(
                        type="text",
                        text=json.dumps({
                            "success": False,
                            "error": f"未知的工具: {tool_name}"
                        }, ensure_ascii=False)
                    )]
                )
            
            # 调用处理函数
            result = await handlers[tool_name](args)
            
            return CallToolResult(
                content=[TextContent(
                    type="text",
                    text=json.dumps(result, ensure_ascii=False, indent=2)
                )]
            )
            
        except Exception as e:
            logger.error(f"工具调用失败: {str(e)}")
            return CallToolResult(
                content=[TextContent(
                    type="text",
                    text=json.dumps({
                        "success": False,
                        "error": f"工具调用失败: {str(e)}"
                    }, ensure_ascii=False)
                )]
            )
    
    async def handle_list_prompts(self, request: ListPromptsRequest) -> ListPromptsResult:
        """处理提示词列表请求"""
        return ListPromptsResult(prompts=self.prompts)
    
    async def handle_get_prompt(self, request: GetPromptRequest) -> GetPromptResult:
        """处理获取提示词请求"""
        prompt_name = request.name
        args = request.arguments or {}
        
        if prompt_name == "document_generation_system":
            user_question = args.get("user_question", "")
            template_info = args.get("template_info", {})
            
            prompt_text = f"""你是一个专业的文档生成助手。请根据以下信息生成高质量的文档内容：

用户需求：{user_question}

使用模板：{template_info.get('name', '未指定')}
模板描述：{template_info.get('description', '无描述')}
需要填充的字段：{', '.join(template_info.get('fields', []))}

请为每个字段生成专业、详细且符合实际的内容。内容应该：
1. 符合字段的目的和要求
2. 与用户需求高度相关
3. 结构清晰，表达准确
4. 具有实用价值

生成内容时请考虑文档的整体逻辑性和一致性。"""
            
        elif prompt_name == "content_optimization":
            field_name = args.get("field_name", "")
            current_content = args.get("current_content", "")
            
            prompt_text = f"""请优化以下文档字段的内容：

字段名称：{field_name}
当前内容：
{current_content}

请从以下方面进行优化：
1. 内容的准确性和相关性
2. 语言表达的专业性
3. 结构的逻辑性
4. 信息的完整性

优化后的内容应该更加专业、清晰和实用。"""
        else:
            prompt_text = "未找到指定的提示词"
        
        return GetPromptResult(
            description=f"生成的{prompt_name}提示词",
            messages=[
                {
                    "role": "user",
                    "content": TextContent(type="text", text=prompt_text)
                }
            ]
        )
    
    async def handle_list_resources(self, request: ListResourcesRequest) -> ListResourcesResult:
        """处理资源列表请求"""
        return ListResourcesResult(resources=self.resources)

# CLI入口函数
async def run_server():
    """运行MCP服务器"""
    server = MCPServer()
    # 这里用 'cat' 作为占位命令
    async with stdio_client(StdioServerParameters(command="cat")) as session:
        logger.info("MCP文档生成服务器已启动")
        while True:
            try:
                await asyncio.sleep(1)
            except KeyboardInterrupt:
                logger.info("服务器正在关闭...")
                break
            except Exception as e:
                logger.error(f"服务器运行错误: {str(e)}")

def main():
    """主函数"""
    print("🚀 智能文档生成 MCP Server")
    print("=" * 50)
    
    # 检查依赖
    try:
        import jieba
        import docx
        from sklearn.feature_extraction.text import TfidfVectorizer
        print("✅ 所有依赖已安装")
    except ImportError as e:
        print(f"❌ 缺少依赖: {e}")
        print("\n请安装以下依赖:")
        print("pip install jieba python-docx scikit-learn httpx")
        return
    
    # 创建必要的目录
    os.makedirs("templates", exist_ok=True)
    os.makedirs("generated_docs", exist_ok=True)
    
    print("📁 目录结构已创建")
    print("🔧 正在初始化服务器...")
    
    # 运行服务器
    try:
        asyncio.run(run_server())
    except KeyboardInterrupt:
        print("\n👋 服务器已停止")

if __name__ == "__main__":
    main()